/**
 * 全局蓝牙管理模块
 * 提供全局可访问的蓝牙连接状态和方法
 */

import BluetoothManager from '@/utility/bluetooth.js';

// 单例模式，确保整个应用只有一个蓝牙管理实例
class GlobalBluetoothManager {
  constructor() {
    this.bluetoothManager = BluetoothManager;
    this.isInitialized = false;
    this.connectionListeners = [];
    this.dataReceivedListeners = [];
    
    // 设置连接状态监听
    this._setupConnectionListener();
  }
  
  /**
   * 获取单例实例
   */
  static getInstance() {
    if (!GlobalBluetoothManager.instance) {
      GlobalBluetoothManager.instance = new GlobalBluetoothManager();
    }
    return GlobalBluetoothManager.instance;
  }
  
  /**
   * 设置蓝牙连接状态监听
   */
  _setupConnectionListener() {
    // 在蓝牙连接状态变化时通知所有监听器
    uni.onBLEConnectionStateChange((res) => {
      // 通知所有注册的监听器
      this.connectionListeners.forEach(listener => {
        try {
          listener(res);
        } catch (error) {
          console.error('蓝牙连接状态监听器执行出错:', error);
        }
      });
    });
  }
  
  /**
   * 初始化蓝牙模块
   */
  async init() {
    if (this.isInitialized) {
      return Promise.resolve({ errMsg: "蓝牙模块已初始化" });
    }
    
    try {
      const result = await this.bluetoothManager.initBluetooth();
      this.isInitialized = true;
      return result;
    } catch (error) {
      console.error('全局蓝牙初始化失败:', error);
      throw error;
    }
  }
  
  /**
   * 连接蓝牙设备
   * @param {String} deviceId 设备ID
   */
  async connect(deviceId) {
    try {
      // 确保蓝牙已初始化
      if (!this.isInitialized) {
        await this.init();
      }
      
      // 如果已经连接到相同设备，则直接返回成功
      if (this.bluetoothManager.connectedDeviceId === deviceId) {
        return { errMsg: "已连接到该设备" };
      }
      
      // 如果已连接到其他设备，先断开
      if (this.bluetoothManager.connectedDeviceId) {
        await this.disconnect();
      }
      
      // 连接设备
      return await this.bluetoothManager.connectDevice(deviceId);
    } catch (error) {
      console.error('全局蓝牙连接失败:', error);
      throw error;
    }
  }
  
  /**
   * 断开蓝牙连接
   */
  async disconnect() {
    try {
      return await this.bluetoothManager.disconnectDevice();
    } catch (error) {
      console.error('全局蓝牙断开连接失败:', error);
      throw error;
    }
  }
  
  /**
   * 发送数据到蓝牙设备
   * @param {ArrayBuffer} data 要发送的数据
   */
  async sendData(data) {
    try {
      return await this.bluetoothManager.sendData(data);
    } catch (error) {
      console.error('全局蓝牙发送数据失败:', error);
      throw error;
    }
  }
  
  /**
   * 获取蓝牙设备的服务
   * @param {String} deviceId 设备ID
   */
  async getDeviceServices(deviceId) {
    try {
      const result = await this.bluetoothManager._getBLEDeviceServices(deviceId);
      // 确保返回的是服务数组
      return result && result.services ? result.services : [];
    } catch (error) {
      console.error('获取蓝牙设备服务失败:', error);
      throw error;
    }
  }
  
  /**
   * 获取蓝牙服务的特征值
   * @param {String} deviceId 设备ID
   * @param {String} serviceId 服务ID
   */
  async getCharacteristics(deviceId, serviceId) {
    try {
      const result = await this.bluetoothManager._getBLEDeviceCharacteristics(deviceId, serviceId);
      // 确保返回的是特征值数组
      return result && result.characteristics ? result.characteristics : [];
    } catch (error) {
      console.error('获取蓝牙特征值失败:', error);
      throw error;
    }
  }
  
  /**
   * 启用/禁用蓝牙特征值通知
   * @param {String} deviceId 设备ID
   * @param {String} serviceId 服务ID
   * @param {String} characteristicId 特征值ID
   * @param {Boolean} state 是否启用通知
   */
  async notifyCharacteristic(deviceId, serviceId, characteristicId, state) {
    try {
      return await this.bluetoothManager._notifyBLECharacteristicValueChange(deviceId, serviceId, characteristicId, state);
    } catch (error) {
      console.error('设置蓝牙特征值通知失败:', error);
      throw error;
    }
  }
  
  /**
   * 获取最后一次错误信息
   */
  getLastError() {
    // 如果bluetoothManager有getLastError方法，则使用它
    if (typeof this.bluetoothManager.getLastError === 'function') {
      return this.bluetoothManager.getLastError();
    }
    
    // 否则返回空对象
    return { phase: '未知', message: '未知错误', code: -1 };
  }
  
  /**
   * 添加蓝牙连接状态监听器
   * @param {Function} listener 监听器函数
   */
  addConnectionListener(listener) {
    if (typeof listener === 'function' && !this.connectionListeners.includes(listener)) {
      this.connectionListeners.push(listener);
    }
  }
  
  /**
   * 移除蓝牙连接状态监听器
   * @param {Function} listener 要移除的监听器函数
   */
  removeConnectionListener(listener) {
    const index = this.connectionListeners.indexOf(listener);
    if (index !== -1) {
      this.connectionListeners.splice(index, 1);
    }
  }
  
  /**
   * 设置全局数据接收回调
   * @param {Function} callback 数据接收回调函数
   */
  setDataReceivedCallback(callback) {
    if (typeof callback === 'function') {
      // 清除旧的监听器
      this.bluetoothManager.removeOnDataReceivedCallback();
      
      // 设置新的监听器
      this.bluetoothManager.setOnDataReceivedCallback((data) => {
        // 首先调用直接回调
        callback(data);
        
        // 然后通知所有其他监听器
        this.dataReceivedListeners.forEach(listener => {
          if (listener !== callback) {
            try {
              listener(data);
            } catch (error) {
              console.error('数据接收监听器执行出错:', error);
            }
          }
        });
      });
      
      // 将回调添加到监听器列表
      if (!this.dataReceivedListeners.includes(callback)) {
        this.dataReceivedListeners.push(callback);
      }
    }
  }
  
  /**
   * 添加数据接收监听器
   * @param {Function} listener 数据接收监听器
   */
  addDataReceivedListener(listener) {
    if (typeof listener === 'function' && !this.dataReceivedListeners.includes(listener)) {
      this.dataReceivedListeners.push(listener);
      
      // 如果这是第一个监听器，需要设置蓝牙回调
      if (this.dataReceivedListeners.length === 1) {
        this.bluetoothManager.setOnDataReceivedCallback((data) => {
          // 通知所有监听器
          this.dataReceivedListeners.forEach(l => {
            try {
              l(data);
            } catch (error) {
              console.error('数据接收监听器执行出错:', error);
            }
          });
        });
      }
    }
  }
  
  /**
   * 移除数据接收监听器
   * @param {Function} listener 要移除的监听器
   */
  removeDataReceivedListener(listener) {
    const index = this.dataReceivedListeners.indexOf(listener);
    if (index !== -1) {
      this.dataReceivedListeners.splice(index, 1);
      
      // 如果没有监听器了，移除蓝牙回调
      if (this.dataReceivedListeners.length === 0) {
        this.bluetoothManager.removeOnDataReceivedCallback();
      }
    }
  }
  
  /**
   * 获取当前已连接设备ID
   * @returns {String|null} 设备ID
   */
  getConnectedDeviceId() {
    return this.bluetoothManager.connectedDeviceId;
  }
  
  /**
   * 检查蓝牙是否已连接
   * @returns {Boolean} 是否已连接
   */
  isConnected() {
    return !!this.bluetoothManager.connectedDeviceId;
  }
  
  /**
   * 检查是否正在连接
   * @returns {Boolean} 是否正在连接
   */
  isConnecting() {
    return this.bluetoothManager.isConnecting || false;
  }
  
  /**
   * 清除所有监听器
   */
  clearAllListeners() {
    this.connectionListeners = [];
    this.dataReceivedListeners = [];
    this.bluetoothManager.removeOnDataReceivedCallback();
    uni.offBLEConnectionStateChange();
    this._setupConnectionListener(); // 重新设置基本监听
  }
}

// 创建单例实例
const globalBluetoothManager = GlobalBluetoothManager.getInstance();

export default globalBluetoothManager; 